# mp4_cut.py：视频素材剪辑
#
# 1. 查看字幕过程中，在线标记要剪辑的地方，1个~是只剪这一个(暂时只实现这个) ，2个~是开始，3个~是结束  位于文字上，时间位于文字上方  间隔5秒以内的不分开  不自动合并，而是将文件重命名后复制到新建文件夹
# 2. 手动执行脚本进行指定路径下的文件转换，为doc并命名（从1开始）保存到固定位置/云盘 两个参数： 读出和写入的路径
# -3. 下拉脚本文件，自动比对原字幕文件，找到要剪辑的位置进行视频剪辑命名和保存 三个参数：云盘搜索关键字，原字幕和视频路径
# 3. 上一步修改为不自动更新srt，而是手动下载到待剪区，只传入待剪区、原视频路径即可；和根据待剪区的图片进行剪辑差不多，前者传文件夹，后者传文件
# 4. 视频去水印和后期处理（画质优化，重命名，封面截取，加片头片尾等），一个参数：单个视频或视频文件夹路径和名字
# 4. 尝试根据打击节奏识别出特定画面
# 5. 将N秒一张的截图放到自动创建的指定路径

# 待实现：
# srt转doc
# 查找变动srt
# 识别剪辑的时间戳字符
# 进行剪辑
# -将最新修改的文件排序后，下载此页，依次比较这个文件和同步区的此文件的hash值是否变化
# -变化了认为是修改了，保留此文件，否则删除，继续下一个文件比较
# -判断完毕后将修改后的文件全部替换同步区文件，删除后缀后移动到原路径
# 在指定待剪区根据图片名称去指定路径修改指定文件，按照图片上的时间
# 上一步操作传入待剪区路径上一级（多图片路径上级）、mp4文件路径   原则一次剪一个文件
# 在待剪区找不到粗剪两个字 默认不进行 找到后自动计算要剪的图片前后秒数，根据相邻文件名字
# 剪辑成片仍放到此粗剪路径下  命名是pic名字

# 根据srt剪，原则是一次剪多个文件，传入待剪区路径上一级（多字幕路径上级）、mp4文件夹路径
# 其它同上面，输出命名是集数加srt词条

# 需要修改的全局变量或配置：
# 关闭网盘自动更新和桌面通知
# 配置夸克云盘的同步区路径和下拉临时区路径
# 视频素材成片路径
# 字幕上一级文件夹要合适且准确
# pip install python-docx
# pic和srt的路径关键词不能修改 也是同步路径


import smtplib
import sys
import io

import docx

import eyed3
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
from email.mime.application import MIMEApplication
from pydub import AudioSegment
import email
import imaplib
import os
import shutil
import time
import traceback
import zipfile
from email.header import decode_header, Header
from email.utils import parseaddr
from pathlib import Path
import datetime
import pyautogui
import pyperclip
from moviepy.editor import VideoFileClip
import hashlib
from moviepy.editor import *
import pandas as pd
import requests
import base64
import base64
import urllib
import requests

API_KEY = "oCq3Gj1TY185Mjk5PmWqnSIc"
SECRET_KEY = "PDTC04xlWW9FaliZZM0bYopbOC1tYGOT"

DEBUG = 1
PC_COM = 1  # 0-家庭 1-公司
PIC_KEY = "pic_temp"
SRT_KEY = "srt_temp"
VIDEO_KEY = "video_temp"

remote_server_url = 'imap.qq.com'
email_url = "3324564761@qq.com"  # 当前使用邮箱
password = "ioaeproulegrchff"
email_msg_to = "1984832368@qq.com"  # 发送邮箱
check_time = 10 # n 秒检测一次是否更新

srt_check_path = "D:\\video\\video_temp\\海绵宝宝系列\\第2季"  # 字幕文件检索路径
pic_syn_path = "D:\\video\\pic_temp"  # 图片文件同步路径
srt_syn_path = "D:\\video\\srt_temp"  # 字幕文件云盘同步路径 不可删除 否则云盘要重新配置
check_hash_path = "D:\\video\\check_hash_temp"  # 下拉后需要比对hash的文件路径 用后即删
quark_exe_path = '"D:\\Program Files\\quark-cloud-drive\\QuarkCloudDrive.exe"'  # 夸克云盘路径

rewrite_print = print
def print(*arg):
   rewrite_print(*arg)
   output_dir = "log_file"
   if not os.path.exists(output_dir):
         os.makedirs(output_dir)
   log_name = 'log.txt' # 日志文件名称
   filename = os.path.join(output_dir, log_name)
   rewrite_print(*arg,file=open(filename,"a")) # 写入文件

def print_d(*arg): #仿真调试用
    if DEBUG == 1:
        print('------调试打印开始-----')
        print(*arg)
        print('------调试打印结束-----\r\n')

class doc_function():  # 文件操作
    def save_data_txt(data):  # 添加数据到文件
        info_str = str(data)
        info_str += '\r\n'
        print(info_str)
        with open('flash_tool.log', 'a') as lead:
            lead.write(info_str)

    def set_data(data):  # 重写文件
        data_w = "data  " + data
        fi = open('data.txt', 'w', encoding='utf-8')
        fi.write(data_w)

    def mkdir(path):  # 新建文件夹
        folder = os.path.exists(path)

        if not folder:  # 判断是否存在文件夹如果不存在则创建为文件夹
            os.makedirs(path)  # makedirs 创建文件时如果路径不存在会创建这个路径
            print("---  creat new folder...  ---")
        else:
            print("new folder is:", path)

    def copyfile_no_dele(srcfile, dstpath):  # 复制文件 如果目标路径存在同名文件则不复制
        if not os.path.isfile(srcfile):
            print("%s not exist!" % (srcfile))
        else:
            fpath, fname = os.path.split(srcfile)  # 分离文件名和路径
            sample_name = srt_syn_path + "\\" + fname
            if os.path.exists(sample_name) == False:
                shutil.copy(srcfile, dstpath)  # 复制文件
            else:
                print("\r\n不进行复制，已经存在文件", sample_name)

    def copyfile_dele(srcfile, dstpath):  # 复制文件 如果目标路径存在同名文件则删除源文件
        if not os.path.isfile(srcfile):
            print("%s not exist!" % (srcfile))
        else:
            fpath, fname = os.path.split(srcfile)  # 分离文件名和路径
            sample_name = srt_syn_path + "\\" + fname
            if os.path.exists(sample_name) == False: # 不存在同名文件
                shutil.copy(srcfile, dstpath)  # 复制文件
            else:
                os.remove(sample_name) # 删除源文件
                shutil.copy(srcfile, dstpath)  # 复制文件

    def file_zip(start_file, zip_dir):  # 压缩文件
        # start_dir 要压缩的文件
        # zip_file 输出zip文件的路径
        fpath_start_dir, fname = os.path.split(start_file)  # 分离文件名和路径

        zip_file = zip_dir + '.zip'
        z = zipfile.ZipFile(zip_file, 'w', zipfile.ZIP_DEFLATED)
        print(z)
        for path, dirname, file_name in os.walk(fpath_start_dir):
            # print("文件夹根路径：", path)
            fpath = path.replace(fpath_start_dir, '')  # 去除根路径名称
            # print("--去除根路径：", fpath)
            fpath = fpath and fpath + os.sep  # 在原fpath加上\
            # print("****去除根路径+\ ：", fpath)

            for filename in file_name:  # 逐个循环读取文档名称
                if filename.find(fname) >= 0:
                    # print(filename)
                    z.write(os.path.join(path, filename), fpath + filename)  # 实现在输出路径的Zip压缩操作
        z.close()


    def file_unzip_download(unzip_file):
        print(f"开始进行解压缩并下载···")

        zip_file = zipfile.ZipFile(unzip_file)
        fpath, fname = os.path.split(unzip_file)
        out_file = fpath + "\\unzip"
        if os.path.isdir(out_file):
            shutil.rmtree(out_file)
            os.mkdir(out_file)
        else:
            os.mkdir(out_file)
        for names in zip_file.namelist():
            zip_file.extract(names, out_file)
        zip_file.close()
        folder = Path(out_file.strip())
        result = list(folder.rglob(f'*{".hex"}*'))  # 只要hex文件
        print(result[0])  # 默认一个压缩包只有一个文件
        flash_file = str(result[0])
        # 进行文件的各种操作处理
        shutil.rmtree(out_file)

    def search_file(key_word, self_path=None):  # 查找的关键字 self_path是自定义路径
        if self_path != None:
            folder_str = self_path
        else:
            folder_str = os.path.join(os.getcwd(), qq_email_rx.Subject)  # 刘森 新世界

        folder = Path(folder_str.strip())
        # print(folder)
        if folder.exists():
            print("开始根据关键字查找文件···")
        else:
            print("未找到存放关键字对应文件的文件夹")
            return None

        result = list(folder.rglob(f'*{key_word}*'))
        if not result:
            print(f'在{folder} 下未找到关键字名称 {key_word} 的文件夹或文件')
            return None
        else:
            # print(f'在{folder} 下找到关键字名称 {key_word} 的文件夹或文件{result}')
            return result

    def get_str_row_column(words): #获取字符串中行数和列的最大字符数，返回两者的最大值
        row = words.count("\n") + 1

        # 存储所有的相同字符之间的距离
        length = []
        loc = 0
        last_loc = 0

        while words.find("\n", loc+1) != -1:
            loc = words.find("\n", loc+1)

            length.append(loc - last_loc)
            last_loc = loc

        length.append(len(words) - last_loc) # 获取最后一行长度
        # print(length)
        # print(f'最大长度：{max(length)}')
        column = max(length)
        # print(max(row, column))
        return max(row, column)

    def delete_files(file_path):
        if os.path.exists(file_path):
            shutil.rmtree(file_path)
            return True
        else:
            # file not found message
            print(f'要删除的文件夹{file_path}找不到')
            return False

    def diff_delete_file(path1, path2): # 对比两个文件夹，删除path1中多余文件
        fileName1 = set([_ for _ in os.listdir(path1)])
        fileName2 = set([_ for _ in os.listdir(path2)])
        # print_d(path1, fileName1, path2, fileName2)
        diffs = fileName1.difference(fileName2)  # fileName1对比fileName2，fileName1中多出来的文件；注意，如果fileName2里有fileName1中没有的文件，也不会筛选出来
        filePath = [os.path.join(path1, i) for i in diffs]
        for file in filePath:
            os.remove(file)
        print("删除的文件有：", filePath)

    def hash(file_path, Bytes=1024):  # 计算文件hash
        md5_value = hashlib.md5()  # 创建一个md5算法对象
        with open(file_path, 'rb') as f:  # 打开一个文件，必须是'rb'模式打开
            while 1:
                data = f.read(Bytes)  # 由于是一个文件，每次只读取固定字节
                if data:  # 当读取内容不为空时对读取内容进行update
                    md5_value.update(data)
                else:  # 当整个文件读完之后停止update
                    break
        ret = md5_value.hexdigest()  # 获取这个文件的MD5值
        return ret

    def read_docx(docName):  # 返回以文字为key 开始时间 结束时间为元素的字典值
        document = open(docName, encoding='utf-8-sig', errors='ignore')
        file = document.read()
        doc_data_list = file.splitlines()
        time_stamp = dict()
        last_data = ""
        for data in doc_data_list:
            if data.count('~') == 1 or data.count('～') == 1:  # 只要这一行
                start_end = []
                start_end.append(last_data[3:8])
                start_end.append(last_data[20:25])
                time_stamp[str(data)] = start_end

            last_data = data

        print(time_stamp)
        return time_stamp


    def srt_doc(srt_path, doc_path):  # srt文件转换为doc文件
        check_file = ".srt"
        file_list = doc_function.search_file(check_file, srt_path)
        if file_list[0] == None:  # 未找到一个srt文件
            print(f'在{srt_path}路径下未找到srt文件，请确认查找路径是否正确')
        else:
            # 将所有srt文件复制到 doc_path 同步路径下面
            srt_no_syn = ""
            doc_function.mkdir(doc_path)  # 创建文件夹
            index = 0
            for srt_file in file_list:
                doc_function.copyfile_no_dele(srt_file, doc_path)  # 将srt复制到对应子文件夹
                # 将文件名字后缀改为doc
                fpath, fname = os.path.split(srt_file)
                syn_file = doc_path + "\\" + fname
                portion = os.path.splitext(syn_file)
                newname = portion[0] + ".doc"
                # syn_file = doc_path + "\\" + str(index) + ".doc"  # 后续强制转换为数字
                # index = index + 1
                try:
                    os.rename(syn_file, newname)
                    srt_no_syn = "\r\n" + srt_no_syn + fpath + "\\" + fname + "\r\n"
                except:
                    print("文件已存在")
                    os.remove(syn_file)
                    continue

            if srt_no_syn == "":
                print(f'在{srt_path}路径下未找到未同步的srt文件，之前已全部同步')
            else:
                print(f'在{srt_path}路径下找到未同步的srt文件：{srt_no_syn}， 并进行同步成功')

    def kuake_download(key_word, download_path = check_hash_path):  # 夸克云盘下载
        # 网盘初始化
        pyautogui.hotkey('win', 'd')  # 先清空屏幕
        os.startfile(quark_exe_path)  # 将软件放到桌面上
        time.sleep(1)
        pyautogui.hotkey('alt', ' ', 'X')  # 将文件窗口最大化
        time.sleep(1)
        pyautogui.hotkey('alt', ' ', 'X')  # 将文件窗口最大化
        doc_function.mkdir(check_hash_path)  # 创建用于比对hash的文件夹 也是下拉内容临时存放区

        # 进行一页网盘文档数据的下载
        gui.move_click(62, 62, 0.1)  # 点击首页
        gui.move_click(1510, 48, 0.1)  # 点击搜索框
        pyperclip.copy(key_word)  # 输入查找文件/文件夹
        pyautogui.hotkey('ctrl', 'v')
        gui.check_completed(449, 205, 158, 197, 255)  # 等待检索完成
        gui.move_click(449, 205, 0.1)  # 点击文件夹
        gui.check_completed(485, 295, 221, 221, 221)  # 等待刷新
        gui.move_click(406, 353, 0.1)  # 点击全选
        gui.move_click(1695, 123, 0.1)  # 点击下载
        time.sleep(1)
        pyautogui.hotkey('alt', ' ', 'X')  # 将文件窗口最大化
        gui.move_click(1674, 74, 0.1)  # 点击输出框
        pyperclip.copy(check_hash_path)  # 输入下载路径
        pyautogui.hotkey('ctrl', 'v')
        pyautogui.press('enter')
        gui.move_click(1955, 1296, 0.1)  # 点击选择文件夹

        # 等待下载完成
        gui.move_click(62, 270, 1)  # 点击传输
        gui.move_click(225, 198, 1)  # 点击下载
        gui.move_click(429, 135, 1)  # 点击正在下载
        gui.check_completed(420, 303, 255, 255, 255)  # 判断是否下载完
        time.sleep(0.2)
        gui.check_completed(420, 303, 255, 255, 255)  # 判断是否下载完 多次确认

    def diff_file_check(old_folder=None, new_folder=check_hash_path):  # 变动文件查找，返回hash值变化的文件
        doc_function.diff_delete_file(new_folder, old_folder)  # 删除多余文件
        # 文件对比
        srt_syn = ""
        new_file_list = []
        files = os.listdir(new_folder)
        for file in files:  # 进行文件的比对 通过hash值
            new_file_path = new_folder + "\\" + file
            hash_new = doc_function.hash(new_file_path)
            old_file_path = old_folder + "\\" + file
            hash_old = doc_function.hash(old_file_path)
            if hash_new != hash_old:  # 文件变化
                srt_syn = "\r\n" + srt_syn + old_file_path + "\r\n"
                print("文件发生改动：", new_file_path)
                # doc_function.copyfile_dele(new_file_path, old_folder)  # 复制新文件到老路径下面 后期要加
                new_file_list.append(new_file_path)

        return new_file_list

    def mp4_cut_by_srt(mp4_path, srt_path):  # mp4_path :文件路径  srt_path：要修改的文件名字和时间戳所在文件夹
        # print(mp4_path, srt_path)
        mp4_path_list = os.listdir(mp4_path)
        mp4_path_list.sort()  # 对读取的路径进行排序
        mp4_list = []
        for filename in mp4_path_list:
            mp4_list.append(os.path.join(mp4_path, filename))

        srt_name_list = []
        srt_name_list_temp = os.listdir(srt_path)

        for srt in srt_name_list_temp:
            if srt.find("doc") > 0:
                srt_name_list.append(srt)
        srt_name_list.sort()

        srt_list = []
        for filename in srt_name_list:
            srt_list.append(os.path.join(srt_path, filename))

        # print(mp4_list)
        # print(srt_list)

        for srt_name in srt_list:  # 目前只针对电视剧
            fpath, fname = os.path.split(srt_name)
            fname = fname[:-4]  # 去掉后缀

            if fname.find("~") > 0:  # 是mp4输出文件
                print("")
            else:  # 根据关键词查找 而不是序号
                if doc_function.search_file(fname, mp4_path) == None:
                    print("没有找到和srt相同名字的mp4")
                else:
                    result = doc_function.search_file(fname, mp4_path)
                    for file in result:
                        name = str(file)
                        name = name.split("\\")[-1][:-4]
                        if name == fname and str(file).find(".mp4") > 0:
                            # print(name, file)
                            mp4_name = str(file)
                            # print(mp4_name)
                            doc_function.mp4_cut(srt_name, mp4_name)


        # doc_function.delete_files(check_hash_path)  # 将临时文件夹删除

    def mp4_cut(srt, mp4):  # 根据srt文件对mp4进行剪切 剪切识别符见简介或readme
        print(f'开始根据{srt}  对  {mp4}进行剪切')
        time_stamp = doc_function.read_docx(str(srt))
        fpath, fname = os.path.split(srt)
        mp4_name = mp4.split('\\')[-1][:-4]

        word_num = 0
        word_dict = dict()
        end_sec = 0
        end_sec_last = 0
        start_sec_first = 0
        word_sum = ""
        for key in time_stamp:
            if len(time_stamp[key][0]) > 5:  # 时分秒
                dt_start = datetime.datetime.strptime(time_stamp[key][0], '%H:%M:%S')
                dt_end = datetime.datetime.strptime(time_stamp[key][1], '%H:%M:%S')
            else:  # 分秒
                dt_start = datetime.datetime.strptime(time_stamp[key][0], '%M:%S')
                dt_end = datetime.datetime.strptime(time_stamp[key][1], '%M:%S')

            start_sec = dt_start.hour * 3600 + dt_start.minute * 60 + dt_start.second
            end_sec = dt_end.hour * 3600 + dt_end.minute * 60 + dt_end.second
            if start_sec_first == 0:  # 第一次更新初始时间的位置
                start_sec_first = start_sec

            # print("----%d", (start_sec-end_sec_last))
            if end_sec_last != 0 and (start_sec - end_sec_last) > 5:  # 开始时间和上一次的时间大于5才认为是一帧 开始剪切
                start = min(start_sec_first-1, end_sec_last+5)
                end = max(start_sec_first-1, end_sec_last+5)
                clip = VideoFileClip(mp4).subclip(start, end)  # 前后预留的时间
                # print("----", start_sec_first, end_sec_last)
                start_sec_first = start_sec  # 更新初始时间

                new_file = fpath + "\\" + mp4_name + "_" + word_sum + ".mp4"  #  输出路径仍是srt粗剪区，命名为视频名+关键字
                clip.write_videofile(new_file)
                clip.close()

                word_dict[word_num] = word_sum
                word_sum = ""
                word_num = word_num + 1

            end_sec_last = end_sec
            word_sum = word_sum + key
            # print(new_file)
            # print(start_sec, end_sec)


        # 以上一级路径为名字创建excel，以集数为列名进行添加 内容 新行  保存路径为上一级路径  根据名字进行重组另起一行
        excel_name = fpath + "\\" + mp4.split('\\')[-2] + ".xlsx"
        if os.path.exists(excel_name) == False:   # 不存在则新建
            df = pd.DataFrame()
            df.to_excel(excel_name)

        df = pd.read_excel(excel_name, sheet_name="Sheet1", dtype={0: "string"})
        excel_dict = df.to_dict()
        print(word_dict)
        excel_dict[f'{mp4_name}'] = word_dict
        # print(word_dict)
        excel_all = pd.DataFrame(excel_dict)
        with pd.ExcelWriter(excel_name, mode='a', if_sheet_exists='replace') as writer:  # 有则覆盖
            excel_all.to_excel(writer, index=False, sheet_name="Sheet1")

    def mp4_cut_by_pic(mp4_path, pic_path):  # 通过pic进行素材剪切 mp4_path=0 则进行对多个视频的粗剪
        print(pic_path)
        pic_name_list = []
        mp4_name_list = []
        pic_name_list_temp = os.listdir(pic_path)
        for pic in pic_name_list_temp:
            if pic.find("jpg") > 0:
                pic_name_list.append(pic)
            elif pic.find("mp4") > 0:
                mp4_name_list.append(pic)
        pic_name_list.sort()
        # print(len(pic_name_list), pic_name_list[0][:3])
        if len(pic_name_list) <= 1 or int(pic_name_list[0][:3]) <= 1:
            print("pic数量过少，或pic名字位置过前")
        pic_list = []
        # 计算间隔时间
        dt = datetime.datetime.strptime(pic_name_list[0].split('_')[-1][:-4], '%H.%M.%S')
        first_sec = dt.hour * 3600 + dt.minute * 60 + dt.second
        dt = datetime.datetime.strptime(pic_name_list[1].split('_')[-1][:-4], '%H.%M.%S')
        second_sec = dt.hour * 3600 + dt.minute * 60 + dt.second
        time_space = 5
        if mp4_path != 0:
            time_space = (second_sec - first_sec) / (int(pic_name_list[1][:3]) - int(pic_name_list[0][:3]))
            time_space = int(time_space)

        for filename in pic_name_list:
            pic_list.append(os.path.join(pic_path, filename))
            dt = datetime.datetime.strptime(filename.split('_')[-1][:-4], '%H.%M.%S')
            sec = dt.hour * 3600 + dt.minute * 60 + dt.second
            start_sec = sec
            end_sec = sec + time_space

            new_file = pic_path + "\\" + filename[:-4] + ".mp4"  # 输出路径仍是pic粗剪区，命名为视频名+关键字
            if os.path.exists(new_file) == False:  # 如果之前没有生成过mp4 说明是新的pic才剪切和上传
                if mp4_path != 0:
                    clip = VideoFileClip(mp4_path).subclip(start_sec, end_sec)  # 前后预留时间
                    # print("是单个mp4文件")
                else:
                    mp4_path_parent = Path(pic_path).parent
                    mp4_path_parent_list = os.listdir(mp4_path_parent)
                    for mp4_name in mp4_path_parent_list:
                        if filename.split('_')[-2].find(mp4_name[:-4]) > 0:  # 找到和pic名字对应的视频
                            # print(mp4_path_parent, filename.split('_')[-2], mp4_name)
                            mp4_path_signal = str(mp4_path_parent) + "\\" + mp4_name
                            clip = VideoFileClip(mp4_path_signal).subclip(start_sec, end_sec)  # 前后预留时间
                clip.write_videofile(new_file)
                clip.close()

                # baidu_yun.push_pic(pic_list[-1])  # 上传


        # print(pic_list)

    def mp4_creat_by_excel(excel_name):  # 通过excel中的字幕进行视频生成  改为按序号重命名后复制到指定文件夹
        fpath, fname = os.path.split(excel_name)
        # 获取列，以列名为输出标题 下面的内容为单元
        if os.path.exists(excel_name):  # excel 存在
            df = pd.read_excel(excel_name, sheet_name="Sheet1", dtype={0: "string"}, keep_default_na=False)
            excel_dict = df.to_dict()
            mp4_name_list = excel_dict.keys()
            print(excel_dict, mp4_name_list)

            for mp4_name in mp4_name_list:  # 获取每一列
                name_inx = 0
                clip_list = []
                mp4_cut_name_list = excel_dict[mp4_name].values()
                dstpath = fpath + "\\" + mp4_name  # 新建文件夹
                # print(dstpath, fpath, mp4_name)
                doc_function.mkdir(dstpath)
                print(mp4_cut_name_list)
                for mp4_cut_name in mp4_cut_name_list:  # 获取每列的每一个素材
                    if mp4_cut_name != "":  # 获取路径
                        mp4_cut_path = doc_function.search_file(mp4_cut_name, fpath)[0]
                        mp4_cut_path = str(mp4_cut_path)
                        # print(mp4_cut_path)
                        name_inx = name_inx + 1
                        new_mp4_name = dstpath + "\\" + str(name_inx) + ".mp4"  # 修改名字
                        shutil.copy(mp4_cut_path, new_mp4_name)
                        # os.rename(mp4_cut_path, new_mp4_name)
                        # os.remove(mp4_cut_path)

                        # clip = VideoFileClip(str(mp4_cut_path))
                        # clip_list.append(clip)
                        # clip.close()

                # final_clip = concatenate_videoclips(clip_list)

                # print(new_mp4_file)
                # final_clip.to_videofile(new_mp4_file, fps=30, remove_temp=False)



        # 根据内容单元去找对应的素材


    def video_images(image_speed_time, mp4_files_list): # 将视频按几秒一帧输出为图片 mp4_files_list 文件夹或文件路径  speed_time_image: 几秒出1张
        image_speed = 1 / image_speed_time
        if os.path.isdir(mp4_files_list):  # 文件夹
            mp4_names = os.listdir(mp4_files_list)
            # 在pic_syn_path中以mp4_files_list最后文件夹创建文件夹
            pic_top_path = pic_syn_path + "\\" + mp4_files_list.split('\\')[-1] + "pic"
            doc_function.mkdir(pic_top_path)

        elif os.path.isfile(mp4_files_list):  # 文件
            mp4_names = []
            mp4_names.append(mp4_files_list.split('\\')[-1])
            # 在pic_syn_path中以mp4_files_list最后文件名创建文件夹
            pic_top_path = pic_syn_path
            # print(mp4_names, pic_top_path, image_speed_time)

        for mp4 in mp4_names:
            mp4_path = mp4_files_list + "\\" + mp4
            if os.path.isfile(mp4_files_list):  # 文件
                mp4_path = mp4_files_list
            # print(mp4_path)
            pic_bottom_path = pic_top_path + "\\" + mp4[:-4]  # 第几集
            if not os.path.exists(pic_bottom_path):  # 如果不存在文件夹就新建，并存放图片
                doc_function.mkdir(pic_bottom_path)
                clipV = VideoFileClip(mp4_path)
                # 在此文件夹存放截图
                jpg_name = pic_bottom_path + "\\%03d.jpg"
                clipV.write_images_sequence(jpg_name, image_speed)  # 视频输出成图片，0.5表示2秒输出一张图片
                clipV.close()
                # 将文件以上两级路径+时间重命名
                pics_path_bottom_names = os.listdir(pic_bottom_path)
                pic_top_name = mp4_files_list.split('\\')[-1]
                for pic in pics_path_bottom_names:
                    seconds = int(pic[:-4]) * image_speed_time
                    m, s = divmod(seconds, 60)
                    h, m = divmod(m, 60)
                    date_str = str(h) + "." + str(m) + "." + str(s)
                    old_name = pic_bottom_path + "\\" + pic
                    new_name = pic[:-4] + "_" + pic_top_name + mp4[:-4] + "_"  + date_str + ".jpg"
                    if os.path.isfile(mp4_files_list):  # 文件
                        new_name = pic[:-4] + "_" + mp4[:-4] + "_"  + date_str + ".jpg"
                    new_name = pic_bottom_path + "\\" + new_name
                    print(old_name, new_name)
                    os.rename(old_name, new_name)


            # break

class baidu_yun:
    def push_pic(pic_path):  # pic_path：要上传的文件夹路径
        request_url = "https://aip.baidubce.com/rest/2.0/image-classify/v1/realtime_search/similar/add"
        # 二进制方式打开图片文件
        f = open(pic_path, 'rb')
        img = base64.b64encode(f.read())

        fpath, fname = os.path.split(pic_path)  # 分离文件名和路径
        # params = {"brief": "{\"name\":\"海绵宝宝\", \"id\":\"1\"}", "image": img}
        params = dict()
        params["brief"] = str(fname[:-4])
        params["image"] = img
        # print(params)
        request_url = request_url + "?access_token=" + baidu_yun.get_access_token()
        headers = {'content-type': 'application/x-www-form-urlencoded'}
        response = requests.post(request_url, data=params, headers=headers)
        if response:
            print(response.json())


    def get_file_content_as_base64(path, urlencoded=False):
        """
        获取文件base64编码
        :param path: 文件路径
        :param urlencoded: 是否对结果进行urlencoded
        :return: base64编码信息
        """
        with open(path, "rb") as f:
            content = base64.b64encode(f.read()).decode("utf8")
            if urlencoded:
                content = urllib.parse.quote_plus(content)
        return content


    def get_access_token():
        """
        使用 AK，SK 生成鉴权签名（Access Token）
        :return: access_token，或是None(如果错误)
        """
        url = "https://aip.baidubce.com/oauth/2.0/token"
        params = {"grant_type": "client_credentials", "client_id": API_KEY, "client_secret": SECRET_KEY}
        return str(requests.post(url, params=params).json().get("access_token"))


if __name__ == '__main__':
    # doc_function.mp4_creat_by_excel("D:\\video\\srt_temp\\我的团长我的团srt\\粗剪\\字幕混剪.xlsx")
    doc_function.mp4_cut_by_srt("D:\\video\\video_temp\\我的团长我的团", "D:\\video\\srt_temp\\我的团长我的团srt\\粗剪")
    # doc_function.mp4_cut_by_pic("D:\\video\\video_temp\\海绵宝宝系列\\海绵宝宝第1季\\第01集.mp4", "D:\\video\\pic_temp\\海绵宝宝第1季pic\\第01集\\粗剪")
    # baidu_yun.push_pic("D:\\video\\pic_temp\\海绵宝宝第1季pic\\第01集\\002_海绵宝宝第1季第01集_0.0.40.jpg")
    # doc_function.video_images(sys.argv[1], int(sys.argv[2]))

    if len(sys.argv) == 2:  # 单个excel路径  自动根据excel的第2个及以后的sheet进行内容拼接
        if sys.argv[1].find("D:\\") >= 0:
            print(f'excel路径是：{sys.argv[1]}')
            doc_function.mp4_creat_by_excel(sys.argv[1])
        else:
            print("请输入待处理的excel路径")

    elif len(sys.argv) == 3:
        if (sys.argv[1].find("D:\\") >= 0 or sys.argv[1].find("F:\\") >= 0 or sys.argv[1].find("G:\\") >= 0) and sys.argv[2].find("D:\\") >= 0:  # 转换srt为doc，读出和写入的文件夹路径
            if sys.argv[2].find(SRT_KEY) >= 0:  # 根据srt剪mp4
                print(f'mp4文件夹路径{sys.argv[1]}，srt粗剪文件夹路径{sys.argv[2]}')
                doc_function.mp4_cut_by_srt(sys.argv[1], sys.argv[2])
            elif sys.argv[2].find(PIC_KEY) >= 0:  # 根据pic剪mp4
                print(f'mp4文件路径{sys.argv[1]}，pic粗剪文件夹路径{sys.argv[2]}')
                doc_function.mp4_cut_by_pic(sys.argv[1], sys.argv[2])
            else:
                print(f'srt输入路径{sys.argv[1]}，doc输出文件夹路径{sys.argv[2]}')
                doc_function.srt_doc(sys.argv[1], sys.argv[2])

        elif sys.argv[1].isdigit() == True and (sys.argv[2].find("D:\\") >= 0 or sys.argv[2].find("F:\\") >= 0 or sys.argv[2].find("G:\\") >= 0):  # 视频截图 文件或文件夹路径 + 隔几秒一张
            if int(sys.argv[1]) != 0:
                print(f'截图视频的截图间隔时间{sys.argv[1]}, 输入文件或文件夹路径{sys.argv[2]}')
                doc_function.video_images(int(sys.argv[1]), sys.argv[2])   # 每隔这些秒截图一张
            else:
                print(f'输入文件夹路径{sys.argv[2]},每隔3秒扫描一次是否有更新，有则进行pic转mp4，截取5s时长')
                pic_num = 0
                pic_num_last = 0
                while True:
                    time.sleep(3)
                    pic_num = len(doc_function.search_file("jpg", sys.argv[2]))
                    if pic_num > pic_num_last:
                        doc_function.mp4_cut_by_pic(0, sys.argv[2])
                        pic_num_last = pic_num


    else:
        print(f'请输入:\r\n'
              f' excel路径                      --自动根据excel的第2个及以后的sheet进行视频内容拼接\r\n'
              f' srt输入       doc输出文件夹路径  --srt的提取和转换(路径内不能有重名路径)\r\n'
              f' mp4文件夹路径  srt粗剪文件夹路径  --通过srt进行视频素材剪辑\r\n'
              f' mp4文件路径    pic粗剪文件夹路径  --通过pic进行视频素材剪辑\r\n'
              f' 帧截取时间     视频文件或文件夹    --对视频间隔N秒进行帧截取\r\n'
              f' 帧截取时间(0)  视频文件夹        --监测文件夹变动，自动根据图片截取5秒视频\r\n'
              f' 其它 -待定')

    # input()
    sys.exit(0)

    pass



